import json
import logging

from submodules.common.lib.log_ import logger

def update_dict_rec(base_dict, new_data):
    '''
    递归更新,将new_data中的值更新到base_dict
    '''
    if type(base_dict) != type(new_data):
        logger.error("base_dict与new_data类型不一致")
        return base_dict
    # 检查new_data是否为JSON字符串
    if isinstance(new_data, str):
        try:
            # 尝试解析JSON字符串
            new_data = json.loads(new_data)
        except json.JSONDecodeError:
            # 如果不是有效的JSON字符串，则抛出异常
            raise ValueError("The provided string is not a valid JSON.")

            # 如果new_data是字典，递归更新
    if isinstance(new_data, dict):
        for key, value in new_data.items():
            if key in base_dict and isinstance(base_dict[key], dict) and isinstance(value, dict):
                # 如果键存在且都是字典，递归更新
                base_dict[key] = update_dict_rec(base_dict[key], value)
            else:
                # 否则，直接更新键的值
                base_dict[key] = value
                # 如果new_data是列表，递归更新列表中的字典元素
    elif isinstance(new_data, list):
        for i, item in enumerate(new_data):
            if isinstance(item, dict):
                # 如果列表元素是字典，且base_dict中对应位置也是字典，则递归更新
                if i < len(base_dict) and isinstance(base_dict[i], dict):
                    base_dict[i] = update_dict_rec(base_dict[i], item)
                else:
                    # 否则，将新字典添加到base_dict中
                    base_dict.append(item)
            else:
                # 如果列表元素不是字典，直接添加到base_dict中（假设base_dict足够长）
                if i < len(base_dict):
                    base_dict[i] = item
                else:
                    base_dict.append(item)
    else:
        # 如果new_data不是字典或列表，直接更新整个base_dict
        base_dict = new_data

    return base_dict


def update_json_rec(j1, j2):
    d1 = json.loads(j1)
    d2 = json.loads(j2)
    res = update_dict_rec(d1, d2)
    return json.dumps(res)


def is_subdict(d1, d2):
    '''
    判断dict1是否包含dict2，返回bool值
    '''
    # 数据类型不同，直接返回
    if type(d1) != type(d2):
        return False
    else:
        # 均为dict
        if isinstance(d1, dict):
            # {}空dict，直接返回
            if not d2:
                return True
            # key不包含，直接返回
            for key, value2 in d2.items():
                if key not in d1:
                    return False
            # 对比key,以d2为基准
            for key, value in d2.items():
                # 可递归，继续递归
                if isinstance(value, dict) or isinstance(value, list):
                    return is_subdict(d1[key], d2[key])
                # 不可递归，直接比较
                else:
                    if d1[key] != d2[key]:
                        return False
        # 均为list
        elif isinstance(d1, list):
            # 长度大于，直接返回
            if len(d2) > len(d1):
                return False
            # 以d2的长度遍历
            for i in range(len(d2)):
                # 可递归，继续递归
                if isinstance(d1[i], dict) or isinstance(d2[i], list):
                    return is_subdict(d1[i], d2[i])
                # 不可递归，直接比较
                else:
                    if d1[i] != d2[i]:
                        return False
        # 具体值，直接比较
        else:
            if d1 != d2:
                return False
    return True


if __name__ == "__main__":
    def update_dict_rec():
        d1 = {
            "11": {
                "21": "21-d1",
                "22": "22",
                "31": {
                    "41": "41",
                }
            }
        }
        d2 = {
            "11": {
                "22": "22-d2",
                "31": {
                    "42": "42-d2"
                }
            }
        }
        d = update_dict_rec(d1, d2)
        print(d)

    def test_is_subdict():
        d1 = [1, 2, 3]
        d2 = [1]
        res = is_subdict(d1, d2)
        print(res)
        d1 = [1]
        d2 = [1, 2]
        res = is_subdict(d1, d2)
        print(res)
        d1 = [[1, 2], [3, 4]]
        d2 = [[1]]
        res = is_subdict(d1, d2)
        print(res)
        d1 = [[1, 2], [3, 4]]
        d2 = [[1, 2, 3]]
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": "1", "b": "2"}
        d2 = {"a": "1"}
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": "1"}
        d2 = {"a": "1", "b": "2"}
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": {"b": "2", "c": "3"}}
        d2 = {"a": {"b": "2"}}
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": {"b": "2"}}
        d2 = {"a": {"b": "2", "c": "3"}}
        res = is_subdict(d1, d2)
        print(res)
        d1 = [1, {"a": "1", "b": "2"}]
        d2 = [1, {"a": "1"}]
        res = is_subdict(d1, d2)
        print(res)
        d1 = [1, {"a": "1", "b": "2"}]
        d2 = [1, {"a": "1", "c": "3"}]
        res = is_subdict(d1, d2)
        print(res)
        d1 = [1, 2, {"a": "1", "b": "2"}]
        d2 = [1, {"a": "1"}]
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": "1", "b": [{"c": "2", "d": "4"}]}
        d2 = {"a": "2", "b": [{"c": "2", "d": "4"}]}
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": "1", "aa": "11", "b": [{"c": "2", "d": "4"}]}
        d2 = {"a": "1", "b": [{"c": "2"}]}
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": "1", "aa": "11", "b": [{"c": "2", "d": "4"}]}
        d2 = {"b": [{"c": "2"}]}
        res = is_subdict(d1, d2)
        print(res)
        d1 = {"a": "1", "aa": "11", "b": [{"c": "2", "d": "4"}]}
        d2 = {"b": []}
        res = is_subdict(d1, d2)
        print(res)
